Mac Mania 2/MacMania 2.toast/Demo's/Tools&Utilities/Programming/QT MovieToolBox/other QT code not used yet/QuickDraw Movies Library.c

C/C++ Source or Header | 1993-05-25 | 5.2 KB | 236 lines | [TEXT/KAHL]

/*
    File:        QuickDraw Movies Library.c

    Contains:    Some routines simplify basic movie construction.

    Written by:    xxx put writers here xxx

    Copyright:    © 1991 by Apple Computer, Inc., all rights reserved.

    Change History (most recent first):

        <1+>    11/12/91    dvb        Bring into the present, November 1991.
         <1>      8/7/91    dvb        first checked in

    To Do:
*/

/*
    File:        Quickdraw Movies Library.c

*/

/*
 * file: Graphics Movies Library.c
 *
 * started 15 December 1990 13:39:32 Saturday
 * david van brink
 *
 * Some routines to make it a snap! to make quickdraw movies.
 *
 */


#define noFrameDiffx

#include <QuickDraw.h>
#include <QDOffscreen.h>
#include <Memory.h>

#include <Movies.h>
#include <MoviesFormat.h>
#include <ImageCompression.h>

#include "QuickDraw Movies Library.h"

/*-----------------------------
    Constants
-----------------------------*/

#define kDefaultTemporalQuality 3L
#define kDefaultKeyFrameRate 20

#define kFixedPointUnity 0x00010000

/*-----------------------------
    Prototypes
-----------------------------*/
static void FailNil(long x);
#define FailNil(x) FailNil((long)(x))

/*-----------------------------
    Routines
-----------------------------*/

void InitializeMovieRecorder(MovieRecorder *mr,GWorldPtr gw,unsigned char *fileName,long frameRate,
        long compressionType,long compressionQuality)
    {
    short thisError;
    long compressedFrameSize;

    mr->compressionType = compressionType;
    mr->compressionQuality = compressionQuality;
    mr->temporalQuality = kDefaultTemporalQuality<<8;
    mr->keyFrameRate = kDefaultKeyFrameRate;
    mr->gWorldPtr = gw;
    mr->pixMapH = gw->portPixMap;

//    if(mr->compressionType == 'rpza')
    //    mr->destDepth = 16;
    //else
    //    mr->destDepth = (**mr->pixMapH).pixelSize;

    mr->time = 0;

    mr->imageDescriptionH = (ImageDescription **)NewHandle(0);

    /*
     * Assume we record from
     *  the entire viewDevice.
     */

    mr->sourceRect = (**mr->pixMapH).bounds;

    /*
     * Create the file, and the track, and the media.
     */

    FSMakeFSSpec(0,0,fileName,&mr->movieDataSpec);

    thisError = CreateMovieFile( &mr->movieDataSpec, 'TVOD', 0,createMovieFileDeleteCurFile,
            &mr->resourceRefNum,&mr->movie);        /* deletes old one */

    mr->track = NewMovieTrack(mr->movie,
        (long)( mr->sourceRect.right - mr->sourceRect.left)<<16,
        (long)(mr->sourceRect.bottom - mr->sourceRect.top)<<16,
        0);

    mr->media = NewTrackMedia(mr->track, VIDEO_TYPE,frameRate, 0,0);

    BeginMediaEdits(mr->media);

    /*
     * Find out how much buffer to allocate
     * for compression, and allocate it.
     */


    thisError = GetMaxCompressionSize(mr->pixMapH,&mr->sourceRect,
            0,
            mr->compressionQuality,
            mr->compressionType,0,&compressedFrameSize);
    if(thisError)    Debugger();

#ifndef noFrameDiff
    thisError = CompressSequenceBegin(&mr->sequenceID,
            mr->pixMapH,0,    /*mr->previousPixMapH,*/
            &mr->sourceRect,nil,
            0,
            mr->compressionType,0,mr->compressionQuality,
            mr->temporalQuality,mr->keyFrameRate,nil,
            codecFlagUpdatePrevious,mr->imageDescriptionH);
#endif

    if(thisError) Debugger();

    mr->compressedFrameBitsH = NewHandle(compressedFrameSize);
    FailNil(mr->compressedFrameBitsH);
    }

void AddMovieRecorderFrame(mr)
/*
  * Record the next frame out of the
  * MovieRecorder's viewDevice
  */
    register MovieRecorder *mr;
{
    long compressedFrameSize;
    short thisError;
    ImageDescription **idH;
    unsigned char similarity;

    idH = (ImageDescription **)NewHandle(0);

    HLock(mr->compressedFrameBitsH);

#ifdef noFrameDiff
    thisError = CompressImage(mr->pixMapH,&mr->sourceRect,
            mr->compressionQuality,mr->compressionType,
            idH,*mr->compressedFrameBitsH);
#else

    thisError = CompressSequenceFrame(mr->sequenceID,mr->pixMapH,&mr->sourceRect,
            codecFlagUpdatePrevious,*mr->compressedFrameBitsH,&compressedFrameSize, &similarity,nil);

    (**mr->imageDescriptionH).dataSize = 0;
#endif
    if(thisError) Debugger();


    HUnlock(mr->compressedFrameBitsH);

#ifdef noFrameDiff
    thisError = AddMediaSample(mr->media,mr->compressedFrameBitsH,
            0,(**idH).dataSize,1,(SampleDescriptionHandle)idH, 1,0,&mr->time);
#else
    thisError = AddMediaSample(mr->media,mr->compressedFrameBitsH,
            0,compressedFrameSize,1,
            (SampleDescriptionHandle)mr->imageDescriptionH,
            1,similarity ? mediaSampleNotSync : 0,&mr->time);
#endif
    if(thisError)    Debugger();

    mr->time++;

    DisposHandle((Handle)idH);
    }


void TerminateMovieRecorder(mr)
    MovieRecorder *mr;
{
    short thisError;
    short resRefNum;
    TimeValue mediaDuration,trackDuration,movieDuration;

#ifdef noFrameDiff
#else
    CDSequenceEnd(mr->sequenceID);
#endif

    EndMediaEdits(mr->media);

    mediaDuration = GetMediaDuration(mr->media);

    thisError = InsertMediaIntoTrack(mr->track,0,0,mediaDuration,kFixedPointUnity);

    trackDuration = GetTrackDuration(mr->track);
    movieDuration = GetMovieDuration(mr->movie);

    thisError = OpenMovieFile(&mr->movieDataSpec, &resRefNum, fsRdWrPerm);
    thisError = AddMovieResource( mr->movie, resRefNum, 0, 0);
    thisError = CloseMovieFile(resRefNum);

    DisposeHandle(mr->compressedFrameBitsH);

    SetMoviePreferredRate( mr->movie, kFixedPointUnity );
    thisError = GetMoviesError();

    DisposeMovie(mr->movie);
    thisError = GetMoviesError();

    }



#undef FailNil
static void FailNil(x)
    long x;
    {
    if(!x)
        {
        DebugStr((unsigned char *)"\pOut of memory.");
        ExitToShell();
        }
    }